# This Python file uses the following encoding: utf-8
import heapq
import os

import fasttext
import pandas as pd
import numpy as np
import torch
from torch_geometric.data import Data
from torch_geometric.nn import GCNConv

# 从这往下都pingfen的内容
from paddleocr import PaddleOCR
import re

need_name = ['求职意向', '教育背景', '实习经验', '工作经验', '项目经验', '个人技能', '技能证书', '技能特长',
             '技能专长',
             '兴趣爱好', '校园活动', '自我评价', '荣誉奖项', '奖项荣誉']


def extract_text_from_image(image_path):
    ocr = PaddleOCR(use_angle_cls=True, use_gpu=False)  # 使用CPU预加载，不用GPU
    result = ocr.ocr(image_path, cls=True)  # 打开图片文件
    # 打印所有文本信息
    text = []
    for t in result:
        for k in t:
            text.append(k[1][0])

    return text


def get_xueli(original_list, substrings_to_check):
    """
    从文本中得到学历
    :param original_list:提取的文本列表
    :param substrings_to_check:检查的文本列表
    :return:对应的学历
    """
    matched_substrings = set()
    for item in original_list:
        for substring in substrings_to_check:
            if substring in item and substring not in matched_substrings:
                matched_substrings.add(substring)
    if "博士" in matched_substrings:
        return "博士"
    elif {"硕士", "研究生"}.issubset(matched_substrings):
        return "硕士"
    elif "本科" in matched_substrings:
        return "本科"
    elif "大专" in matched_substrings:
        return "大专"
    else:
        return "无学历"





def get_xingxi(text_list):
    result =text_list

    book_i = []
    name_i = []
    for i in range(len(result)):
        if result[i] in need_name:
            book_i.append(i)
            name_i.append(result[i])
    use = {}
    for j in range(len(book_i) - 1):
        use[result[book_i[j]]] = []
        for i in range(book_i[j], book_i[j + 1]):
            use[result[book_i[j]]].append(result[i])
    use[result[book_i[len(book_i) - 1]]] = []
    for i in range(book_i[len(book_i) - 1], len(result)):
        use[result[book_i[len(book_i) - 1]]].append(result[i])

    return use, need_name


def get_values(use, name_i):
    values = ['无学历', 0, 0, 0, 0, 0]
    for i in range(len(name_i)):
        if name_i[i] in use.keys():
            if i == 2 or i == 3 or i == 4:
                pattern = re.compile(r'\d{4}\.\d{1,2}-(?:(?:\d{4}\.\d{1,2})|至今)')
                for item in use[name_i[i]]:
                    if pattern.match(item):
                        values[1] += 1
            if i == 5 or i == 6 or i == 7 or i == 8:
                add_zhi = len(use[name_i[i]])
                values[3] = values[3] + add_zhi
            if i == 12 or i == 13:
                add_zhi = len(use[name_i[i]])
                values[4] = values[4] + add_zhi
            if i == 1:
                try:
                    re1 = [item for item in use[name_i[i]] if 'GPA' in item]
                    zhi = re1[0][3:]
                    values[2] = eval(zhi)
                except Exception as e:
                    pass
                xueli = get_xueli(use[name_i[i]], ['本科', '大专', '研究生', '硕士', '博士'])
                values[0] = xueli
            if i == 11:
                add_zhi = len(use[name_i[i]])
                values[5] = values[5] + add_zhi
    if values[0] == "博士":
        values[0] = 10
    elif values[0] == "硕士":
        values[0] = 7
    elif values[0] == "本科":
        values[0] = 4
    elif values[0] == "大专":
        values[0] = 1
    elif values[0] == "无学历":
        values[0] = 0
    values[1] = values[1] * 2 if values[1] * 2 <= 10 else 10
    values[2] = values[2] * 10
    values[3] = values[3] * 1.1 if values[3] * 1.2 <= 10 else 10
    values[4] = values[4] * 1.3 if values[4] * 1.4 <= 10 else 10
    values[5] = values[5] * 1.2 if values[5] * 1.3 <= 10 else 10

    return values

def pingfen_get_result(text_list):
    """

    :param text_list: 简历信息列表
    :return: 结果值
    """
    use, name_i = get_xingxi(text_list)
    values=get_values(use, name_i)
    return values

# 从这往上都pingfen的内容


# 将每一份招聘要求和简历技能构建成图，利用图卷积网络模型，进行各节点间特征结合和特征转换
class GCN(torch.nn.Module):
    def __init__(self):
        super().__init__()
        torch.manual_seed(1234)
        self.conv1 = GCNConv(100, 70)  # 将输入的一百维特征转化为七十维特征
        self.conv2 = GCNConv(70, 10)  # 将输入的七十维特征转化为十维特征
        self.conv3 = GCNConv(10, 5)  # 将输入的十维特征转化为五维特征
        self.classifier = torch.nn.Linear(5, 30)  # 将输入的五维特征转化为三十维特征

    def forward(self, x, edge_index):
        h = self.conv1(x, edge_index)
        h = h.tanh()
        h = self.conv2(h, edge_index)
        h = h.tanh()
        h = self.conv3(h, edge_index)
        h = h.tanh()
        h = self.classifier(h)
        return h


class Recommendation2():

    def transform_features(self, data, model):  # 调用模型得到特征
        """
        Transform the features
        :param data: 传入模型的数据
        :param model: 需传入的模型
        :return: 传入模型后得到的特征值
        """
        transformed_h = model(data.x, data.edge_index)
        return transformed_h

    def getData(self, mydata, Job, model):  # 构建数据集,mydata为一条数据，该函数得到该数据的Data类表示,Job为该数据对应的工作名称
        """
        将简历技能或招聘要求转化成可以传入模型的数据
        :param mydata:一条简历技能数据或招聘要求数据
        :param Job:数据对应的岗位
        :param model:对应技能的词向量模型
        :return:
        """
        x = []
        for word in mydata:
            word = word.replace(",", "")
            temp = model.get_word_vector(word)
            x.append(temp)
        x.append(model.get_word_vector(Job))
        x = np.array(x)
        x = torch.tensor(x)
        length = len(mydata)
        resource = [length] * length
        target = [i for i in range(length)]
        edge_index = torch.tensor([resource, target], dtype=torch.long)
        data = Data(x=x, edge_index=edge_index)
        return data

    def getData1(self, mydata, model):  # 构建数据集,mydata为一条数据，该函数得到该数据的Data类表示,Job为该数据对应的工作名称
        """
        将简历技能或招聘要求转化成可以传入模型的数据
        :param mydata:一条简历技能数据或招聘要求数据
        :param Job:数据对应的岗位
        :param model:对应技能的词向量模型
        :return:
        """
        x = []

        for word in mydata:
            word = word.replace(",", "")
            temp = model.get_word_vector(word)
            x.append(temp)
        x.append(np.zeros(100, dtype=np.float32))
        x = np.array(x)
        x = torch.tensor(x)
        length = len(mydata)
        resource = [length] * length
        target = [i for i in range(length)]
        edge_index = torch.tensor([resource, target], dtype=torch.long)
        data = Data(x=x, edge_index=edge_index)
        return data

    def cosine_similarity(self, vec1, vec2):  # 计算余弦相似度
        """
        计算俩个向量的余弦相似度
        :param vec1: 向量1
        :param vec2: 向量2
        :return: 俩向量的余弦相似度
        """
        dot_product = np.dot(vec1, vec2)
        norm_a = np.linalg.norm(vec1)
        norm_b = np.linalg.norm(vec2)
        return dot_product / (norm_a * norm_b)

    def get_finalData(self, input_csv, output_column, word_model_file):
        """
        读取可直接使用的数据文件，得到最终的数据集
        :param input_csv: 读取文件
        :param output_column: 读取列,其中第一个元素需要为构建数据集的数据列,第二个为对应数据的岗位列，第3个为对应的id列
        :param word_model_file:进行处理的词向量模型
        :return: 最终数据集
        """
        # 导入词向量模型
        model = fasttext.load_model(word_model_file)
        # 加载csv文件
        df = pd.read_csv(input_csv)
        column1 = [text.split() for text in df[output_column[0]]]
        column2 = [text for text in df[output_column[1]]]
        column3 = [text for text in df[output_column[2]]]
        data_all = []
        for i in range(len(column1)):
            data = self.getData(column1[i], column2[i], model)
            data_all.append(data)
        return data_all, column3

    def model_use(self, data_all):
        """
        将数据集的数据传入模型
        :param data_all: 数据集
        :return: 经过模型得到数据集里每一个图的全局特征
        """
        model = GCN()  # 构建图卷积网络模型
        torch.save(model.state_dict(), 'gcn_model.pth')
        data_column_means = []
        for i in range(len(data_all)):
            # 使用模型进行特征转换
            transformed_data_features = self.transform_features(data_all[i], model)
            # 得到全局特征
            column_means = transformed_data_features.mean(dim=0)
            data_column_means.append(column_means.detach().numpy())
        return data_column_means

    def save_features(self, save_file, data_column_means):
        """
        保存文件
        :param save_file: 保存的文件(.npz)
        :param data_data_column_means:保存的数组
        :return:none
        """
        np.savez(save_file, *data_column_means)

    def load_features(self, load_file):
        """
        导入文件
        :param load_file: 导入文件
        :return: 数据集的全局特征
        """
        # 后续读取
        loaded_arrays = np.load(load_file)

        # 将加载的各个数组重新整理成一个列表
        data_column_means = [arr for arr in loaded_arrays.values()]
        return data_column_means

    def get_compare_values(self, mydata, Job, model_file, word_model_file):
        """
        处理推荐处信息时，将其传入model中得到全局特征
        :param mydata: 一条简历技能数据或招聘要求数据
        :param Job: 数据对应的岗位
        :param model_file: GCN模型参数文件
        :param word_model_file: 对应技能的词向量模型参数文件
        :return:
        """
        # 导入词向量模型
        model_use = fasttext.load_model(word_model_file)
        userdata = self.getData(mydata, Job, model_use)
        model = GCN()
        model.load_state_dict(torch.load(model_file))
        # 使用模型进行特征转换
        transformed_data_features = self.transform_features(userdata, model)
        # 得到全局特征
        compare_values = transformed_data_features.mean(dim=0)
        return compare_values.detach().numpy()

    def get_compare_values_user(self, mydata, model_file, word_model_file):
        """
        处理推荐处信息时，将其传入model中得到全局特征
        :param mydata: 一条简历技能数据或招聘要求数据
        :param Job: 数据对应的岗位
        :param model_file: GCN模型参数文件
        :param word_model_file: 对应技能的词向量模型参数文件
        :return:
        """
        # 导入词向量模型
        model_use = fasttext.load_model(word_model_file)
        userdata = self.getData1(mydata, model_use)
        model = GCN()
        model.load_state_dict(torch.load(model_file))
        # 使用模型进行特征转换
        transformed_data_features = self.transform_features(userdata, model)
        # 得到全局特征
        compare_values = transformed_data_features.mean(dim=0)
        return compare_values.detach().numpy()

    def getmax_similarity(self, data_column_means, compare_values):  # 得到compare_values与其他数据的相似度列表
        """
        compare_values是比较特征，与data_column_means中的数据进行相似度比较，得到列表结果
        :param data_column_means:数据集特征
        :param compare_values:需进行相似度比较的数据特征
        :return:列表
        """
        similarity_result = []
        # i_result = []
        for i in range(len(data_column_means)):
            similarity = self.cosine_similarity(data_column_means[i], compare_values)
            similarity_result.append(similarity)
            # i_result.append(i)
        return similarity_result

    def get_recommendation(self, data_column_means, compare_values, result_csv, result_columns, n, operation,
                           use_xueli):
        """
        得到推荐结果，输出结果，返回对应的下标值
        :param data_column_means:数据集全局特征
        :param compare_values:比较数据全局特征
        :param result_csv:结果所在的表
        :param result_columns:表需读取的列,第一个数据为ID信息
        :param n:推荐的个数
        :param operation:推荐时需满足要求的操作函数
        :param use_xueli:需要的学历
        :return:推荐数据的ID
        """
        similarity_result = self.getmax_similarity(data_column_means, compare_values)
        largest_values_indices = heapq.nlargest(len(similarity_result),
                                                ((v, i) for i, v in enumerate(similarity_result)))
        # 分离最大值和下标
        largest_values, indices = zip(*largest_values_indices)
        search_Result = self.myresult(indices, result_csv, result_columns, n, operation, use_xueli)
        return search_Result

    def myresult(self, in_id, result_csv, result_columns, n, operation, use_xueli):

        # 读取CSV文件，并指定只读取所需的列
        specific_columns = result_columns
        df = pd.read_csv(result_csv, usecols=specific_columns)

        # 将DataFrame中的数据类型转换为JSON支持的数据类型
        df = df.astype({
            'ID': str,  # 将ID列的数据类型转换为字符串类型
            '公司名称': str,  # 将公司名称列的数据类型转换为字符串类型
            '岗位': str,  # 将岗位列的数据类型转换为字符串类型
            'salary': str,  # 将salary列的数据类型转换为浮点数类型
            'education': str,  # 将education列的数据类型转换为字符串类型
            'description': str,  # 将description列的数据类型转换为字符串类型
            'link': str  # 将link列的数据类型转换为字符串类型
        })

        ID_need = []
        i_need = []
        for i in range(len(in_id)):
            row_number = in_id[i]
            if operation(use_xueli, df.loc[row_number, result_columns[4]]):
                ID_need.append(df.loc[row_number, result_columns[0]])
                i_need.append(i)
                if len(ID_need) == n:
                    break

        result_list = []
        for k in i_need:
            row_number = in_id[k]
            result_dict = {}
            for column in result_columns:
                result_dict[column] = df.loc[row_number, column]
            result_list.append(result_dict)
        return result_list

    def compare_degrees(self, degree1: str, degree2: str) -> bool:
        degree_order = {"博士": 5, "硕士": 4, "本科": 3, "大专": 2, "无学历": 1}
        # Ensure both degrees are valid and in the degree_order dictionary
        if degree1 not in degree_order or degree2 not in degree_order:
            # raise ValueError("Invalid degree specified. Valid degrees are: 博士, 硕士, 本科, 大专.")
            print("errcv")
        return degree_order[degree1] >= degree_order[degree2]


def missing_technologies(user_stack, job_requirements):
    """
    根据用户技术栈和岗位需求，找出用户不具备的岗位所需技术栈。
    参数:
        user_stack (set[str]): 用户技术栈集合
        job_requirements (set[str]): 岗位需求技术栈集合

    返回值:
        set[str]: 用户不具备的岗位所需技术栈集合
    """
    missing = job_requirements.copy()

    for requirement in job_requirements:
        for skill in user_stack:
            if requirement in skill or skill in requirement:
                missing.remove(requirement)
                break
    text1 = "你具有的技术栈有以下："
    for i in user_stack:
        text1 = text1 + " " + i

    text2 = "在该岗位上，你缺少的技术栈有以下："
    for i in missing:
        text2 = text2 + " " + i
    if missing is None or len(missing) == 0:
        text2 = "你刚好具备该岗位的所要求的所有技术"
    test_len = len(job_requirements)
    if 0 <= len(missing) * 1.0 <= 0.5 * test_len or test_len <= 3:
        text3 = "你的现有技术栈与岗位需求吻合，仅有个别技能有待提升,你的能力展现出：全面性与专业性：已掌握的技能几乎覆盖该岗位所需的全部关键领域，体现了扎实的专业基础和广泛的技术视野。 快速融入与高产出：由于技能缺失较少，预计能够迅速适应岗位工作，初期就能实现较高工作效率，对团队贡献显著。易于弥补短板：少量的技能缺口可通过短期培训、自我学习或团队协作迅速填补，成本相对较低，且不影响整体工作进程。"
    elif 0.5 * test_len < len(missing) * 1.0 <= 0.7 * test_len:
        text3 = "你的现有技术栈与岗位需求较为匹配，存在一些关键或非关键技能的缺失。你的能力展现出：基础稳固与部分专长：在大部分岗位所需技术栈上有稳定的基础，可能在某些领域有突出专长，但在其他技能点上有所欠缺。中期适应与渐进提升：初期可能需要一定时间适应和学习，随着技能提升，工作效能逐步增强，对团队贡献随时间增长。需规划性补强：对于缺失的技能，需要制定明确的学习计划或寻求有针对性的培训，确保技能提升与岗位需求同步发展。"
    elif 0.7 * test_len < len(missing) * 1.0 <= 0.9 * test_len:
        text3 = "你的现有技术栈与岗位需求存在明显差距，涉及多个关键或非关键技能的缺失。你的能力展现出：部分匹配与潜在价值：虽然在某些岗位技能上具备基础，但总体匹配度不高。然而，其在其他领域或岗位的专业知识或经验可能为团队带来独特价值。较长适应期与逐步融入：需要经历一个较长时间的学习和适应过程，初期可能对团队依赖较大，随着时间推移逐渐提升独立工作能力。系统性提升规划：鉴于技能缺口较多，需要制定详尽的技能提升计划，可能包括长期培训、项目实践和导师指导等多种方式，确保用户逐步达到岗位要求。"
    elif 0.9 * test_len < len(missing) * 1.0:
        text3 = "你的现有技术栈与岗位需求严重不符，缺乏大部分关键技能。你的能力展现出：有限匹配度与高转型难度：在岗位所需技术栈中仅有少数技能匹配，你需要进行大规模的知识体系重构和技能转型，面临较大的学习挑战。具备长期学习决心：你可能需要经历一个长期且充满挑战的学习和成长过程，需展现出坚韧的学习意志和持之以恒的精神。具备自我规划能力：鉴于技能差距巨大，你需要具备自主规划学习路径的能力，能够为自己设定明确的学习目标和行动计划，逐步提升自身技术能力以适应岗位需求。"

    # 选择输出结果
    return text1 + "" + text2 + "" + text3


def wanted_jobs_based_on_resume(resume_it: list, education: str, job: str):
    """
    根据简历技能推荐岗位
    :param resume_it: 简历技能名词列表
    :param education: 学历要求
    :return: 推荐的岗位ID列表
    """
    test = Recommendation2()
    current_dir = os.getcwd()

    # 构建到上级目录的路径
    parent_dir = os.path.dirname(current_dir)
    data_column_means = test.load_features(parent_dir+"\\GCN\\my_arrays3_job.npz")
    model_file = parent_dir+'\\GCN\\gcn_model.pth'
    word_model_file = parent_dir+'\\GCN\\ail9_1.bin'
    user_values = test.get_compare_values(resume_it, job, model_file, word_model_file)
    search_Result = test.get_recommendation(data_column_means, user_values,
                                            parent_dir+'\\GCN\\技术栈信息名词.csv',
                                            ['ID', '公司名称', '岗位', 'salary', 'education', 'description', 'link',
                                             '技术栈'], 3, test.compare_degrees, education)
    print("出wanted_jobs_based_on_resume")
    return search_Result


def get_result(mydata, job, user_stack, xueli, user_jianli_text):
    """
    得到最终返回结果
    :param mydata: 用户技术名词
    :param job: 意向岗位
    :param user_stack: 用户技术栈
    :param xueli:学历
    :param user_jianli_text:用户简历信息
    :return: 最终结果
    """

    temp = wanted_jobs_based_on_resume(mydata, xueli, job)
    for i in temp:
        ok_use = [i['技术栈']]
        text = missing_technologies(user_stack, ok_use)
        i['text'] = text
        values = pingfen_get_result(user_jianli_text)
        i['value'] = values
    return temp


def assessment(mydata_n, job, mydata_it, xueli):
    print("进来assessment了")
    user_jianli_text = ['五百丁', '一句话介绍自己，告诉HR为什么选择你而不是别人', '求职意向', '网络测试专员', '22岁',
                        '教育背景', '汉族', '2013.09-2017.07', '五百丁大学', '网络工程专业', '广东广州', '13800138000',
                        '工作经验', 'bd@500d.me', '2016.06-至今', '五百丁技术有限公司', '测试专员', '技能特长', '工作描述：',
                        '编写数个有关电视节目高清度的测试用例，测试该用例测出所在环境能否', '创建、更新不同画质节目的',
                        '功能及创建后能否在数据库中找到；',
                        '·执行测试用例用来测试所在环境能否预定电视节目录制，录制后能播放、',
                        '80%', '80%', '快进等功能。', 'Java', 'VC++', '项目经验', '2016.06-2016.08', '五百丁外包服务公司',
                        '80%', '80%', '见习网络编辑', '工作描述：', 'MindManager', 'Visual Studio',
                        '·负责网络管理、监控、维护的全流程支撑工作；', '·熟练掌握路由器的工作原理和装配方法；',
                        '掌握思科各种互联设备的配置方法，自主安装并升级路由器操作系统。', '兴趣爱好', '2013.09-2015.06',
                        '学生会办公室部门', '干事', '绘画', '唱歌', '游泳', '工作描述：',
                        '·负责学院公共物品的整理、统计工作；',
                        '摄影', '·带领学生会其他成员学院各项晚会及活动拉赞助。', '荣誉奖项', '成绩排名：系前五名',
                        'GPA : 7.277/10', '英语水平：CET6', '奖学金：综合一等奖学金（1次）、综合二等奖学金（4次）', '自我评价',
                        '计算机网络工程专业毕业，有较丰富的网络测试经验，对移动互联网有着强烈']
    result = get_result(mydata_n, job, mydata_it, xueli, user_jianli_text)
    print(result)
    print("从assessment出去了")
    return result


# job = 'java后端工程师'
# mydata_n = ['成绩', 'spring', '特性', 'httpclient', '内容', '木', '队列', '网页', '多线程', 'jar', 'redis', '系统',
#             '两次', '8', '经验', '方案', '50', '男', '基础', '分布式', '架构', '07', '详情', 'mysql', '平台', '后台',
#             '重构', 'qq', '技术', '速度', 'jvm', '外包', '知识', 'maven', 'mybatis', '12214241411', '09', 'sso',
#             '大学', '商品', '算法', 'mycat', '用户', '单点', 'nginx', '端', '产品', '原理', 'tomcat', '手段', '国家',
#             'cap', '12', '集群', '方式', '1200', '问题', '180', '工作', '主流', 'com', '消息', '一等奖', '业务',
#             '有限公司', '背景', 'zookeeper', 'git', '工程师', '框架', '大赛', '论文', '工程', '秒杀', '数据库',
#             '电商', '工具', '技能', 'rabbitmq', '省', '功能', '项目', 'java', '科技', '奖学金', '国家级', '0', 'qps',
#             '三好学生', 'ssm', 'boot']
# mydata_it = ['算法', '计算机科学', 'redis', 'jvm', '管理系统', '高并发', '反向代理', '分布式系统', 'mysql', '外包',
#              'zookeeper', '开发框架', '多线程并发', 'mybatis', '购物系统', '消息队列', '后端', '利用', 'jar包',
#              'java开发', '工程开发', 'git', 'java', '数据库', '项目管理', '分布式', 'nginx', '后端开发', 'tomcat服务器',
#              'maven', '架构', '创业', 'rabbitmq', '运营', '维护', '单点登录', 'kafka', 'pa', '服务器架构', '设计',
#              '开发', '构建工具', 'spring']
# xueli = '本科'
# # user_jianli_text = ['五百丁', '一句话介绍自己，告诉HR为什么选择你而不是别人', '求职意向', '网络测试专员', '22岁',
# #                     '教育背景', '汉族', '2013.09-2017.07', '五百丁大学', '网络工程专业', '广东广州', '13800138000',
# #                     '工作经验', 'bd@500d.me', '2016.06-至今', '五百丁技术有限公司', '测试专员', '技能特长', '工作描述：',
# #                     '编写数个有关电视节目高清度的测试用例，测试该用例测出所在环境能否', '创建、更新不同画质节目的',
# #                     '功能及创建后能否在数据库中找到；',
# #                     '·执行测试用例用来测试所在环境能否预定电视节目录制，录制后能播放、',
# #                     '80%', '80%', '快进等功能。', 'Java', 'VC++', '项目经验', '2016.06-2016.08', '五百丁外包服务公司',
# #                     '80%', '80%', '见习网络编辑', '工作描述：', 'MindManager', 'Visual Studio',
# #                     '·负责网络管理、监控、维护的全流程支撑工作；', '·熟练掌握路由器的工作原理和装配方法；',
# #                     '掌握思科各种互联设备的配置方法，自主安装并升级路由器操作系统。', '兴趣爱好', '2013.09-2015.06',
# #                     '学生会办公室部门', '干事', '绘画', '唱歌', '游泳', '工作描述：',
# #                     '·负责学院公共物品的整理、统计工作；',
# #                     '摄影', '·带领学生会其他成员学院各项晚会及活动拉赞助。', '荣誉奖项', '成绩排名：系前五名',
# #                     'GPA : 7.277/10', '英语水平：CET6', '奖学金：综合一等奖学金（1次）、综合二等奖学金（4次）', '自我评价',
# #                     '计算机网络工程专业毕业，有较丰富的网络测试经验，对移动互联网有着强烈']
# #
# assessment(mydata_n, job, mydata_it, xueli)
#
# def test():
#     print("test")
